1 module directx.d3d9; 2 /*==========================================================================; 3 * 4 * Copyright (C) Microsoft Corporation. All Rights Reserved. 5 * 6 * File: d3d9.h 7 * Content: Direct3D include file 8 * 9 ****************************************************************************/ 10 11 version(Windows): 12 version(Direct3D_9): 13 14 import directx.win32; 15 import directx.d3dcommon; 16 17 struct D3DVIEWPORT9 { 18 DWORD X; 19 DWORD Y; /* Viewport Top left */ 20 DWORD Width; 21 DWORD Height; /* Viewport Dimensions */ 22 float MinZ; /* Min/max of clip Volume */ 23 float MaxZ; 24 } 25 26 struct D3DCLIPSTATUS9 { 27 DWORD ClipUnion; 28 DWORD ClipIntersection; 29 } 30 31 struct D3DMATERIAL9 { 32 D3DCOLORVALUE Diffuse; /* Diffuse color RGBA */ 33 D3DCOLORVALUE Ambient; /* Ambient color RGB */ 34 D3DCOLORVALUE Specular; /* Specular 'shininess' */ 35 D3DCOLORVALUE Emissive; /* Emissive color RGB */ 36 float Power; /* Sharpness if specular highlight */ 37 } 38 39 struct D3DLIGHT9 { 40 D3DLIGHTTYPE Type; /* Type of light source */ 41 D3DCOLORVALUE Diffuse; /* Diffuse color of light */ 42 D3DCOLORVALUE Specular; /* Specular color of light */ 43 D3DCOLORVALUE Ambient; /* Ambient color of light */ 44 D3DVECTOR Position; /* Position in world space */ 45 D3DVECTOR Direction; /* Direction in world space */ 46 float Range; /* Cutoff range */ 47 float Falloff; /* Falloff */ 48 float Attenuation0; /* Constant attenuation */ 49 float Attenuation1; /* Linear attenuation */ 50 float Attenuation2; /* Quadratic attenuation */ 51 float Theta; /* Inner angle of spotlight cone */ 52 float Phi; /* Outer angle of spotlight cone */ 53 } 54 55 struct D3DPRESENTSTATS { 56 UINT PresentCount; 57 UINT PresentRefreshCount; 58 UINT SyncRefreshCount; 59 LARGE_INTEGER SyncQPCTime; 60 LARGE_INTEGER SyncGPUTime; 61 } 62 63 alias DWORD D3DSCANLINEORDERING; 64 enum : D3DSCANLINEORDERING { 65 D3DSCANLINEORDERING_UNKNOWN = 0, 66 D3DSCANLINEORDERING_PROGRESSIVE = 1, 67 D3DSCANLINEORDERING_INTERLACED = 2, 68 } 69 70 struct D3DDISPLAYMODEEX { 71 UINT Size; 72 UINT Width; 73 UINT Height; 74 UINT RefreshRate; 75 D3DFORMAT Format; 76 D3DSCANLINEORDERING ScanLineOrdering; 77 } 78 79 struct D3DDISPLAYMODEFILTER { 80 UINT Size; 81 D3DFORMAT Format; 82 D3DSCANLINEORDERING ScanLineOrdering; 83 } 84 85 alias DWORD D3DDISPLAYROTATION; 86 enum : D3DDISPLAYROTATION { 87 D3DDISPLAYROTATION_IDENTITY = 1, // No rotation. 88 D3DDISPLAYROTATION_90 = 2, // Rotated 90 degrees. 89 D3DDISPLAYROTATION_180 = 3, // Rotated 180 degrees. 90 D3DDISPLAYROTATION_270 = 4 // Rotated 270 degrees. 91 } 92 93 alias D3DTEXTUREFILTERTYPE = DWORD; 94 enum : D3DTEXTUREFILTERTYPE { 95 D3DTEXF_NONE = 0, // filtering disabled (valid for mip filter only) 96 D3DTEXF_POINT = 1, // nearest 97 D3DTEXF_LINEAR = 2, // linear interpolation 98 D3DTEXF_ANISOTROPIC = 3, // anisotropic 99 D3DTEXF_PYRAMIDALQUAD = 6, // 4-sample tent 100 D3DTEXF_GAUSSIANQUAD = 7, // 4-sample gaussian 101 /* D3D9Ex only -- */ 102 D3DTEXF_CONVOLUTIONMONO = 8, // Convolution filter for monochrome textures 103 /* -- D3D9Ex only */ 104 } 105 106 /* 107 * State enumerants for per-sampler texture processing. 108 */ 109 alias D3DSAMPLERSTATETYPE = DWORD; 110 enum : D3DSAMPLERSTATETYPE { 111 D3DSAMP_ADDRESSU = 1, /* D3DTEXTUREADDRESS for U coordinate */ 112 D3DSAMP_ADDRESSV = 2, /* D3DTEXTUREADDRESS for V coordinate */ 113 D3DSAMP_ADDRESSW = 3, /* D3DTEXTUREADDRESS for W coordinate */ 114 D3DSAMP_BORDERCOLOR = 4, /* D3DCOLOR */ 115 D3DSAMP_MAGFILTER = 5, /* D3DTEXTUREFILTER filter to use for magnification */ 116 D3DSAMP_MINFILTER = 6, /* D3DTEXTUREFILTER filter to use for minification */ 117 D3DSAMP_MIPFILTER = 7, /* D3DTEXTUREFILTER filter to use between mipmaps during minification */ 118 D3DSAMP_MIPMAPLODBIAS = 8, /* float Mipmap LOD bias */ 119 D3DSAMP_MAXMIPLEVEL = 9, /* DWORD 0..(n-1) LOD index of largest map to use (0 == largest) */ 120 D3DSAMP_MAXANISOTROPY = 10, /* DWORD maximum anisotropy */ 121 D3DSAMP_SRGBTEXTURE = 11, /* Default = 0 (which means Gamma 1.0, 122 no correction required.) else correct for 123 Gamma = 2.2 */ 124 D3DSAMP_ELEMENTINDEX = 12, /* When multi-element texture is assigned to sampler, this 125 indicates which element index to use. Default = 0. */ 126 D3DSAMP_DMAPOFFSET = 13, /* Offset in vertices in the pre-sampled displacement map. 127 Only valid for D3DDMAPSAMPLER sampler */ 128 } 129 130 alias DWORD D3DQUERYTYPE; 131 enum : D3DQUERYTYPE { 132 D3DQUERYTYPE_VCACHE = 4, /* D3DISSUE_END */ 133 D3DQUERYTYPE_RESOURCEMANAGER = 5, /* D3DISSUE_END */ 134 D3DQUERYTYPE_VERTEXSTATS = 6, /* D3DISSUE_END */ 135 D3DQUERYTYPE_EVENT = 8, /* D3DISSUE_END */ 136 D3DQUERYTYPE_OCCLUSION = 9, /* D3DISSUE_BEGIN, D3DISSUE_END */ 137 D3DQUERYTYPE_TIMESTAMP = 10, /* D3DISSUE_END */ 138 D3DQUERYTYPE_TIMESTAMPDISJOINT = 11, /* D3DISSUE_BEGIN, D3DISSUE_END */ 139 D3DQUERYTYPE_TIMESTAMPFREQ = 12, /* D3DISSUE_END */ 140 D3DQUERYTYPE_PIPELINETIMINGS = 13, /* D3DISSUE_BEGIN, D3DISSUE_END */ 141 D3DQUERYTYPE_INTERFACETIMINGS = 14, /* D3DISSUE_BEGIN, D3DISSUE_END */ 142 D3DQUERYTYPE_VERTEXTIMINGS = 15, /* D3DISSUE_BEGIN, D3DISSUE_END */ 143 D3DQUERYTYPE_PIXELTIMINGS = 16, /* D3DISSUE_BEGIN, D3DISSUE_END */ 144 D3DQUERYTYPE_BANDWIDTHTIMINGS = 17, /* D3DISSUE_BEGIN, D3DISSUE_END */ 145 D3DQUERYTYPE_CACHEUTILIZATION = 18, /* D3DISSUE_BEGIN, D3DISSUE_END */ 146 /* D3D9Ex only -- */ 147 D3DQUERYTYPE_MEMORYPRESSURE = 19, /* D3DISSUE_BEGIN, D3DISSUE_END */ 148 } 149 150 alias D3DCOMPOSERECTSOP = DWORD; 151 enum : D3DCOMPOSERECTSOP { 152 D3DCOMPOSERECTS_COPY = 1, 153 D3DCOMPOSERECTS_OR = 2, 154 D3DCOMPOSERECTS_AND = 3, 155 D3DCOMPOSERECTS_NEG = 4 156 } 157 158 struct D3DVERTEXELEMENT9 { 159 WORD Stream; // Stream index 160 WORD Offset; // Offset in the stream in bytes 161 BYTE Type; // Data type 162 BYTE Method; // Processing method 163 BYTE Usage; // Semantics 164 BYTE UsageIndex; // Semantic index 165 } 166 167 extern (C++) interface IDirect3D9 : IUnknown { 168 HRESULT RegisterSoftwareDevice(void* pInitializeFunction); 169 UINT GetAdapterCount(); 170 HRESULT GetAdapterIdentifier(UINT Adapter,DWORD Flags,D3DADAPTER_IDENTIFIER9* pIdentifier); 171 UINT GetAdapterModeCount(UINT Adapter,D3DFORMAT Format); 172 HRESULT EnumAdapterModes(UINT Adapter,D3DFORMAT Format,UINT Mode,D3DDISPLAYMODE* pMode); 173 HRESULT GetAdapterDisplayMode(UINT Adapter,D3DDISPLAYMODE* pMode); 174 HRESULT CheckDeviceType(UINT Adapter,D3DDEVTYPE DevType,D3DFORMAT AdapterFormat,D3DFORMAT BackBufferFormat,BOOL bWindowed); 175 HRESULT CheckDeviceFormat(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,DWORD Usage,D3DRESOURCETYPE RType,D3DFORMAT CheckFormat); 176 HRESULT CheckDeviceMultiSampleType(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SurfaceFormat,BOOL Windowed,D3DMULTISAMPLE_TYPE MultiSampleType,DWORD* pQualityLevels); 177 HRESULT CheckDepthStencilMatch(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT AdapterFormat,D3DFORMAT RenderTargetFormat,D3DFORMAT DepthStencilFormat); 178 HRESULT CheckDeviceFormatConversion(UINT Adapter,D3DDEVTYPE DeviceType,D3DFORMAT SourceFormat,D3DFORMAT TargetFormat); 179 HRESULT GetDeviceCaps(UINT Adapter,D3DDEVTYPE DeviceType,D3DCAPS9* pCaps); 180 HMONITOR GetAdapterMonitor(UINT Adapter); 181 HRESULT CreateDevice(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DDevice9* ppReturnedDeviceInterface); 182 } 183 184 extern (C++) interface IDirect3DDevice9 : IUnknown { 185 HRESULT TestCooperativeLevel(); 186 UINT GetAvailableTextureMem(); 187 HRESULT EvictManagedResources(); 188 HRESULT GetDirect3D(IDirect3D9* ppD3D9); 189 HRESULT GetDeviceCaps(D3DCAPS9* pCaps); 190 HRESULT GetDisplayMode(UINT iSwapChain,D3DDISPLAYMODE* pMode); 191 HRESULT GetCreationParameters(D3DDEVICE_CREATION_PARAMETERS *pParameters); 192 HRESULT SetCursorProperties(UINT XHotSpot,UINT YHotSpot,IDirect3DSurface9 pCursorBitmap); 193 void SetCursorPosition(int X,int Y,DWORD Flags); 194 BOOL ShowCursor(BOOL bShow); 195 HRESULT CreateAdditionalSwapChain(D3DPRESENT_PARAMETERS* pPresentationParameters,IDirect3DSwapChain9* pSwapChain); 196 HRESULT GetSwapChain(UINT iSwapChain,IDirect3DSwapChain9* pSwapChain); 197 UINT GetNumberOfSwapChains(); 198 HRESULT Reset(D3DPRESENT_PARAMETERS* pPresentationParameters); 199 HRESULT Present(const(RECT)* pSourceRect,const(RECT)* pDestRect,HWND hDestWindowOverride,const(RGNDATA)* pDirtyRegion); 200 HRESULT GetBackBuffer(UINT iSwapChain,UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9* ppBackBuffer); 201 HRESULT GetRasterStatus(UINT iSwapChain,D3DRASTER_STATUS* pRasterStatus); 202 HRESULT SetDialogBoxMode(BOOL bEnableDialogs); 203 void SetGammaRamp(UINT iSwapChain,DWORD Flags,const(D3DGAMMARAMP)* pRamp); 204 void GetGammaRamp(UINT iSwapChain,D3DGAMMARAMP* pRamp); 205 HRESULT CreateTexture(UINT Width,UINT Height,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DTexture9* ppTexture,HANDLE* pSharedHandle); 206 HRESULT CreateVolumeTexture(UINT Width,UINT Height,UINT Depth,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DVolumeTexture9* ppVolumeTexture,HANDLE* pSharedHandle); 207 HRESULT CreateCubeTexture(UINT EdgeLength,UINT Levels,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DCubeTexture9* ppCubeTexture,HANDLE* pSharedHandle); 208 HRESULT CreateVertexBuffer(UINT Length,DWORD Usage,DWORD FVF,D3DPOOL Pool,IDirect3DVertexBuffer9* ppVertexBuffer,HANDLE* pSharedHandle); 209 HRESULT CreateIndexBuffer(UINT Length,DWORD Usage,D3DFORMAT Format,D3DPOOL Pool,IDirect3DIndexBuffer9* ppIndexBuffer,HANDLE* pSharedHandle); 210 HRESULT CreateRenderTarget(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle); 211 HRESULT CreateDepthStencilSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle); 212 HRESULT UpdateSurface(IDirect3DSurface9 pSourceSurface,const(RECT)* pSourceRect,IDirect3DSurface9 pDestinationSurface,const(POINT)* pDestPoint); 213 HRESULT UpdateTexture(IDirect3DBaseTexture9 pSourceTexture,IDirect3DBaseTexture9 pDestinationTexture); 214 HRESULT GetRenderTargetData(IDirect3DSurface9 pRenderTarget,IDirect3DSurface9 pDestSurface); 215 HRESULT GetFrontBufferData(UINT iSwapChain,IDirect3DSurface9 pDestSurface); 216 HRESULT StretchRect(IDirect3DSurface9 pSourceSurface,const(RECT)* pSourceRect,IDirect3DSurface9 pDestSurface,const(RECT)* pDestRect,D3DTEXTUREFILTERTYPE Filter); 217 HRESULT ColorFill(IDirect3DSurface9 pSurface,const(RECT)* pRect,D3DCOLOR color); 218 HRESULT CreateOffscreenPlainSurface(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle); 219 HRESULT SetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9 pRenderTarget); 220 HRESULT GetRenderTarget(DWORD RenderTargetIndex,IDirect3DSurface9* ppRenderTarget); 221 HRESULT SetDepthStencilSurface(IDirect3DSurface9 pNewZStencil); 222 HRESULT GetDepthStencilSurface(IDirect3DSurface9* ppZStencilSurface); 223 HRESULT BeginScene(); 224 HRESULT EndScene(); 225 HRESULT Clear(DWORD Count,const(D3DRECT)* pRects,DWORD Flags,D3DCOLOR Color,float Z,DWORD Stencil); 226 HRESULT SetTransform(D3DTRANSFORMSTATETYPE State,const(D3DMATRIX)* pMatrix); 227 HRESULT GetTransform(D3DTRANSFORMSTATETYPE State,D3DMATRIX* pMatrix); 228 HRESULT MultiplyTransform(D3DTRANSFORMSTATETYPE,const(D3DMATRIX)*); 229 HRESULT SetViewport(const(D3DVIEWPORT9)* pViewport); 230 HRESULT GetViewport(D3DVIEWPORT9* pViewport); 231 HRESULT SetMaterial(const(D3DMATERIAL9)* pMaterial); 232 HRESULT GetMaterial(D3DMATERIAL9* pMaterial); 233 HRESULT SetLight(DWORD Index,const(D3DLIGHT9)*); 234 HRESULT GetLight(DWORD Index,D3DLIGHT9*); 235 HRESULT LightEnable(DWORD Index,BOOL Enable); 236 HRESULT GetLightEnable(DWORD Index,BOOL* pEnable); 237 HRESULT SetClipPlane(DWORD Index,const(float)* pPlane); 238 HRESULT GetClipPlane(DWORD Index,float* pPlane); 239 HRESULT SetRenderState(D3DRENDERSTATETYPE State,DWORD Value); 240 HRESULT GetRenderState(D3DRENDERSTATETYPE State,DWORD* pValue); 241 HRESULT CreateStateBlock(D3DSTATEBLOCKTYPE Type,IDirect3DStateBlock9* ppSB); 242 HRESULT BeginStateBlock(); 243 HRESULT EndStateBlock(IDirect3DStateBlock9* ppSB); 244 HRESULT SetClipStatus(const(D3DCLIPSTATUS9)* pClipStatus); 245 HRESULT GetClipStatus(D3DCLIPSTATUS9* pClipStatus); 246 HRESULT GetTexture(DWORD Stage,IDirect3DBaseTexture9* ppTexture); 247 HRESULT SetTexture(DWORD Stage,IDirect3DBaseTexture9 pTexture); 248 HRESULT GetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD* pValue); 249 HRESULT SetTextureStageState(DWORD Stage,D3DTEXTURESTAGESTATETYPE Type,DWORD Value); 250 HRESULT GetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD* pValue); 251 HRESULT SetSamplerState(DWORD Sampler,D3DSAMPLERSTATETYPE Type,DWORD Value); 252 HRESULT ValidateDevice(DWORD* pNumPasses); 253 HRESULT SetPaletteEntries(UINT PaletteNumber,const(PALETTEENTRY)* pEntries); 254 HRESULT GetPaletteEntries(UINT PaletteNumber,PALETTEENTRY* pEntries); 255 HRESULT SetCurrentTexturePalette(UINT PaletteNumber); 256 HRESULT GetCurrentTexturePalette(UINT *PaletteNumber); 257 HRESULT SetScissorRect(const(RECT)* pRect); 258 HRESULT GetScissorRect(RECT* pRect); 259 HRESULT SetSoftwareVertexProcessing(BOOL bSoftware); 260 BOOL GetSoftwareVertexProcessing(); 261 HRESULT SetNPatchMode(float nSegments); 262 float GetNPatchMode(); 263 HRESULT DrawPrimitive(D3DPRIMITIVETYPE PrimitiveType,UINT StartVertex,UINT PrimitiveCount); 264 HRESULT DrawIndexedPrimitive(D3DPRIMITIVETYPE,INT BaseVertexIndex,UINT MinVertexIndex,UINT NumVertices,UINT startIndex,UINT primCount); 265 HRESULT DrawPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT PrimitiveCount,const(void)* pVertexStreamZeroData,UINT VertexStreamZeroStride); 266 HRESULT DrawIndexedPrimitiveUP(D3DPRIMITIVETYPE PrimitiveType,UINT MinVertexIndex,UINT NumVertices,UINT PrimitiveCount,const(void)* pIndexData,D3DFORMAT IndexDataFormat,const(void)* pVertexStreamZeroData,UINT VertexStreamZeroStride); 267 HRESULT ProcessVertices(UINT SrcStartIndex,UINT DestIndex,UINT VertexCount,IDirect3DVertexBuffer9 pDestBuffer,IDirect3DVertexDeclaration9 pVertexDecl,DWORD Flags); 268 HRESULT CreateVertexDeclaration(const(D3DVERTEXELEMENT9)* pVertexElements,IDirect3DVertexDeclaration9* ppDecl); 269 HRESULT SetVertexDeclaration(IDirect3DVertexDeclaration9 pDecl); 270 HRESULT GetVertexDeclaration(IDirect3DVertexDeclaration9* ppDecl); 271 HRESULT SetFVF(DWORD FVF); 272 HRESULT GetFVF(DWORD* pFVF); 273 HRESULT CreateVertexShader(const(DWORD)* pFunction,IDirect3DVertexShader9* ppShader); 274 HRESULT SetVertexShader(IDirect3DVertexShader9 pShader); 275 HRESULT GetVertexShader(IDirect3DVertexShader9* ppShader); 276 HRESULT SetVertexShaderConstantF(UINT StartRegister,const(float)* pConstantData,UINT Vector4fCount); 277 HRESULT GetVertexShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount); 278 HRESULT SetVertexShaderConstantI(UINT StartRegister,const(int)* pConstantData,UINT Vector4iCount); 279 HRESULT GetVertexShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount); 280 HRESULT SetVertexShaderConstantB(UINT StartRegister,const(BOOL)* pConstantData,UINT BoolCount); 281 HRESULT GetVertexShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount); 282 HRESULT SetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9 pStreamData,UINT OffsetInBytes,UINT Stride); 283 HRESULT GetStreamSource(UINT StreamNumber,IDirect3DVertexBuffer9* ppStreamData,UINT* pOffsetInBytes,UINT* pStride); 284 HRESULT SetStreamSourceFreq(UINT StreamNumber,UINT Setting); 285 HRESULT GetStreamSourceFreq(UINT StreamNumber,UINT* pSetting); 286 HRESULT SetIndices(IDirect3DIndexBuffer9 pIndexData); 287 HRESULT GetIndices(IDirect3DIndexBuffer9* ppIndexData); 288 HRESULT CreatePixelShader(const(DWORD)* pFunction,IDirect3DPixelShader9* ppShader); 289 HRESULT SetPixelShader(IDirect3DPixelShader9 pShader); 290 HRESULT GetPixelShader(IDirect3DPixelShader9* ppShader); 291 HRESULT SetPixelShaderConstantF(UINT StartRegister,const(float)* pConstantData,UINT Vector4fCount); 292 HRESULT GetPixelShaderConstantF(UINT StartRegister,float* pConstantData,UINT Vector4fCount); 293 HRESULT SetPixelShaderConstantI(UINT StartRegister,const(int)* pConstantData,UINT Vector4iCount); 294 HRESULT GetPixelShaderConstantI(UINT StartRegister,int* pConstantData,UINT Vector4iCount); 295 HRESULT SetPixelShaderConstantB(UINT StartRegister,const(BOOL)* pConstantData,UINT BoolCount); 296 HRESULT GetPixelShaderConstantB(UINT StartRegister,BOOL* pConstantData,UINT BoolCount); 297 HRESULT DrawRectPatch(UINT Handle,const(float)* pNumSegs,const(D3DRECTPATCH_INFO)* pRectPatchInfo); 298 HRESULT DrawTriPatch(UINT Handle,const(float)* pNumSegs,const(D3DTRIPATCH_INFO)* pTriPatchInfo); 299 HRESULT DeletePatch(UINT Handle); 300 HRESULT CreateQuery(D3DQUERYTYPE Type,IDirect3DQuery9* ppQuery); 301 HRESULT SetConvolutionMonoKernel(UINT width,UINT height,float* rows,float* columns); 302 HRESULT ComposeRects(IDirect3DSurface9 pSrc,IDirect3DSurface9 pDst,IDirect3DVertexBuffer9 pSrcRectDescs,UINT NumRects,IDirect3DVertexBuffer9 pDstRectDescs,D3DCOMPOSERECTSOP Operation,int Xoffset,int Yoffset); 303 HRESULT PresentEx(const(RECT)* pSourceRect,const(RECT)* pDestRect,HWND hDestWindowOverride,const(RGNDATA)* pDirtyRegion,DWORD dwFlags); 304 HRESULT GetGPUThreadPriority(INT* pPriority); 305 HRESULT SetGPUThreadPriority(INT Priority); 306 HRESULT WaitForVBlank(UINT iSwapChain); 307 HRESULT CheckResourceResidency(IDirect3DResource9* pResourceArray,UINT32 NumResources); 308 HRESULT SetMaximumFrameLatency(UINT MaxLatency); 309 HRESULT GetMaximumFrameLatency(UINT* pMaxLatency); 310 HRESULT CheckDeviceState(HWND hDestinationWindow); 311 } 312 313 extern (C++) interface IDirect3DStateBlock9 : IUnknown { 314 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 315 HRESULT Capture(); 316 HRESULT Apply(); 317 } 318 319 mixin(uuid!(IDirect3DSwapChain9, "794950f2-adfc-458a-905e-10a10b0b503b")); 320 extern (C++) interface IDirect3DSwapChain9 : IUnknown { 321 HRESULT Present(const(RECT)* pSourceRect,const(RECT)* pDestRect,HWND hDestWindowOverride,const(RGNDATA)* pDirtyRegion,DWORD dwFlags); 322 HRESULT GetFrontBufferData(IDirect3DSurface9 pDestSurface); 323 HRESULT GetBackBuffer(UINT iBackBuffer,D3DBACKBUFFER_TYPE Type,IDirect3DSurface9* ppBackBuffer); 324 HRESULT GetRasterStatus(D3DRASTER_STATUS* pRasterStatus); 325 HRESULT GetDisplayMode(D3DDISPLAYMODE* pMode); 326 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 327 HRESULT GetPresentParameters(D3DPRESENT_PARAMETERS* pPresentationParameters); 328 } 329 330 extern (C++) interface IDirect3DResource9 : IUnknown { 331 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 332 HRESULT SetPrivateData(REFGUID refguid,const(void)* pData,DWORD SizeOfData,DWORD Flags); 333 HRESULT GetPrivateData(REFGUID refguid,void* pData,DWORD* pSizeOfData); 334 HRESULT FreePrivateData(REFGUID refguid); 335 DWORD SetPriority(DWORD PriorityNew); 336 DWORD GetPriority(); 337 void PreLoad(); 338 D3DRESOURCETYPE GetType(); 339 } 340 341 extern (C++) interface IDirect3DVertexDeclaration9 : IUnknown { 342 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 343 HRESULT GetDeclaration(D3DVERTEXELEMENT9* pElement,UINT* pNumElements); 344 } 345 346 extern (C++) interface IDirect3DVertexShader9 : IUnknown { 347 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 348 HRESULT GetFunction(void*,UINT* pSizeOfData); 349 } 350 351 extern (C++) interface IDirect3DPixelShader9 : IUnknown { 352 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 353 HRESULT GetFunction(void*,UINT* pSizeOfData); 354 } 355 356 extern (C++) interface IDirect3DBaseTexture9 : IDirect3DResource9 { 357 DWORD SetLOD(DWORD LODNew); 358 DWORD GetLOD(); 359 DWORD GetLevelCount(); 360 HRESULT SetAutoGenFilterType(D3DTEXTUREFILTERTYPE FilterType); 361 D3DTEXTUREFILTERTYPE GetAutoGenFilterType(); 362 void GenerateMipSubLevels(); 363 } 364 365 extern (C++) interface IDirect3DTexture9 : IDirect3DBaseTexture9 { 366 HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc); 367 HRESULT GetSurfaceLevel(UINT Level,IDirect3DSurface9* ppSurfaceLevel); 368 HRESULT LockRect(UINT Level,D3DLOCKED_RECT* pLockedRect,const(RECT)* pRect,DWORD Flags); 369 HRESULT UnlockRect(UINT Level); 370 HRESULT AddDirtyRect(const(RECT)* pDirtyRect); 371 } 372 373 extern (C++) interface IDirect3DVolumeTexture9 : IDirect3DBaseTexture9 { 374 HRESULT GetLevelDesc(UINT Level,D3DVOLUME_DESC *pDesc); 375 HRESULT GetVolumeLevel(UINT Level,IDirect3DVolume9* ppVolumeLevel); 376 HRESULT LockBox(UINT Level,D3DLOCKED_BOX* pLockedVolume,const(D3DBOX)* pBox,DWORD Flags); 377 HRESULT UnlockBox(UINT Level); 378 HRESULT AddDirtyBox(const(D3DBOX)* pDirtyBox); 379 } 380 381 extern (C++) interface IDirect3DCubeTexture9 : IDirect3DBaseTexture9 { 382 HRESULT GetLevelDesc(UINT Level,D3DSURFACE_DESC *pDesc); 383 HRESULT GetCubeMapSurface(D3DCUBEMAP_FACES FaceType,UINT Level,IDirect3DSurface9* ppCubeMapSurface); 384 HRESULT LockRect(D3DCUBEMAP_FACES FaceType,UINT Level,D3DLOCKED_RECT* pLockedRect,const(RECT)* pRect,DWORD Flags); 385 HRESULT UnlockRect(D3DCUBEMAP_FACES FaceType,UINT Level); 386 HRESULT AddDirtyRect(D3DCUBEMAP_FACES FaceType,const(RECT)* pDirtyRect); 387 } 388 389 struct D3DVERTEXBUFFER_DESC { 390 D3DFORMAT Format; 391 D3DRESOURCETYPE Type; 392 DWORD Usage; 393 D3DPOOL Pool; 394 UINT Size; 395 DWORD FVF; 396 } 397 398 struct D3DINDEXBUFFER_DESC { 399 D3DFORMAT Format; 400 D3DRESOURCETYPE Type; 401 DWORD Usage; 402 D3DPOOL Pool; 403 UINT Size; 404 } 405 406 extern (C++) interface IDirect3DVertexBuffer9 : IDirect3DResource9 { 407 HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); 408 HRESULT Unlock(); 409 HRESULT GetDesc(D3DVERTEXBUFFER_DESC *pDesc); 410 } 411 412 extern (C++) interface IDirect3DIndexBuffer9 : IDirect3DResource9 { 413 HRESULT Lock(UINT OffsetToLock,UINT SizeToLock,void** ppbData,DWORD Flags); 414 HRESULT Unlock(); 415 HRESULT GetDesc(D3DINDEXBUFFER_DESC *pDesc); 416 } 417 418 extern (C++) interface IDirect3DSurface9 : IDirect3DResource9 { 419 HRESULT GetContainer(REFIID riid,void** ppContainer); 420 HRESULT GetDesc(D3DSURFACE_DESC *pDesc); 421 HRESULT LockRect(D3DLOCKED_RECT* pLockedRect,const(RECT)* pRect,DWORD Flags); 422 HRESULT UnlockRect(); 423 HRESULT GetDC(HDC *phdc); 424 HRESULT ReleaseDC(HDC hdc); 425 } 426 427 extern (C++) interface IDirect3DVolume9 : IUnknown { 428 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 429 HRESULT SetPrivateData(REFGUID refguid,const(void)* pData,DWORD SizeOfData,DWORD Flags); 430 HRESULT GetPrivateData(REFGUID refguid,void* pData,DWORD* pSizeOfData); 431 HRESULT FreePrivateData(REFGUID refguid); 432 HRESULT GetContainer(REFIID riid,void** ppContainer); 433 HRESULT GetDesc(D3DVOLUME_DESC *pDesc); 434 HRESULT LockBox(D3DLOCKED_BOX * pLockedVolume,const(D3DBOX)* pBox,DWORD Flags); 435 HRESULT UnlockBox(); 436 } 437 438 extern (C++) interface IDirect3DQuery9 : IUnknown { 439 HRESULT GetDevice(IDirect3DDevice9* ppDevice); 440 D3DQUERYTYPE GetType(); 441 DWORD GetDataSize(); 442 HRESULT Issue(DWORD dwIssueFlags); 443 HRESULT GetData(void* pData,DWORD dwSize,DWORD dwGetDataFlags); 444 } 445 446 extern (C++) interface IDirect3D9Ex : IDirect3D9 { 447 UINT GetAdapterModeCountEx(UINT Adapter,const(D3DDISPLAYMODEFILTER)* pFilter ); 448 HRESULT EnumAdapterModesEx(UINT Adapter,const(D3DDISPLAYMODEFILTER)* pFilter,UINT Mode,D3DDISPLAYMODEEX* pMode); 449 HRESULT GetAdapterDisplayModeEx(UINT Adapter,D3DDISPLAYMODEEX* pMode,D3DDISPLAYROTATION* pRotation); 450 HRESULT CreateDeviceEx(UINT Adapter,D3DDEVTYPE DeviceType,HWND hFocusWindow,DWORD BehaviorFlags,D3DPRESENT_PARAMETERS* pPresentationParameters,D3DDISPLAYMODEEX* pFullscreenDisplayMode,IDirect3DDevice9Ex* ppReturnedDeviceInterface); 451 HRESULT GetAdapterLUID(UINT Adapter,LUID * pLUID); 452 } 453 454 extern (C++) interface IDirect3DDevice9Ex : IDirect3DDevice9 { 455 HRESULT CreateRenderTargetEx(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Lockable,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle,DWORD Usage); 456 HRESULT CreateOffscreenPlainSurfaceEx(UINT Width,UINT Height,D3DFORMAT Format,D3DPOOL Pool,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle,DWORD Usage); 457 HRESULT CreateDepthStencilSurfaceEx(UINT Width,UINT Height,D3DFORMAT Format,D3DMULTISAMPLE_TYPE MultiSample,DWORD MultisampleQuality,BOOL Discard,IDirect3DSurface9* ppSurface,HANDLE* pSharedHandle,DWORD Usage); 458 HRESULT ResetEx(D3DPRESENT_PARAMETERS* pPresentationParameters,D3DDISPLAYMODEEX *pFullscreenDisplayMode); 459 HRESULT GetDisplayModeEx(UINT iSwapChain,D3DDISPLAYMODEEX* pMode,D3DDISPLAYROTATION* pRotation); 460 } 461 462 extern (C++) interface IDirect3DSwapChain9Ex : IDirect3DSwapChain9 { 463 HRESULT GetLastPresentCount(UINT* pLastPresentCount); 464 HRESULT GetPresentStats(D3DPRESENTSTATS* pPresentationStatistics); 465 HRESULT GetDisplayModeEx(D3DDISPLAYMODEEX* pMode,D3DDISPLAYROTATION* pRotation); 466 } 467 468 extern (C++) interface IDirect3D9ExOverlayExtension : IUnknown { 469 HRESULT CheckDeviceOverlayType(UINT Adapter,D3DDEVTYPE DevType,UINT OverlayWidth,UINT OverlayHeight,D3DFORMAT OverlayFormat,D3DDISPLAYMODEEX* pDisplayMode,D3DDISPLAYROTATION DisplayRotation,D3DOVERLAYCAPS* pOverlayCaps); 470 } 471 472 extern (C++) interface IDirect3DDevice9Video : IUnknown { 473 HRESULT GetContentProtectionCaps(const(GUID)* pCryptoType,const(GUID)* pDecodeProfile,D3DCONTENTPROTECTIONCAPS* pCaps); 474 HRESULT CreateAuthenticatedChannel(D3DAUTHENTICATEDCHANNELTYPE ChannelType,IDirect3DAuthenticatedChannel9* ppAuthenticatedChannel,HANDLE* pChannelHandle); 475 HRESULT CreateCryptoSession(const(GUID)* pCryptoType,const(GUID)* pDecodeProfile,IDirect3DCryptoSession9* ppCryptoSession,HANDLE* pCryptoHandle); 476 } 477 478 extern (C++) interface IDirect3DAuthenticatedChannel9 : IUnknown { 479 HRESULT GetCertificateSize(UINT* pCertificateSize); 480 HRESULT GetCertificate(UINT CertifacteSize,BYTE* ppCertificate); 481 HRESULT NegotiateKeyExchange(UINT DataSize,VOID* pData); 482 HRESULT Query(UINT InputSize,const(VOID)* pInput,UINT OutputSize,VOID* pOutput); 483 HRESULT Configure(UINT InputSize,const(VOID)* pInput,D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT* pOutput); 484 } 485 486 extern (C++) interface IDirect3DCryptoSession9 : IUnknown { 487 HRESULT GetCertificateSize(UINT* pCertificateSize); 488 HRESULT GetCertificate(UINT CertifacteSize,BYTE* ppCertificate); 489 HRESULT NegotiateKeyExchange(UINT DataSize,VOID* pData); 490 HRESULT EncryptionBlt(IDirect3DSurface9 pSrcSurface,IDirect3DSurface9 pDstSurface,UINT DstSurfaceSize,VOID* pIV); 491 HRESULT DecryptionBlt(IDirect3DSurface9 pSrcSurface,IDirect3DSurface9 pDstSurface,UINT SrcSurfaceSize,D3DENCRYPTED_BLOCK_INFO* pEncryptedBlockInfo,VOID* pContentKey,VOID* pIV); 492 HRESULT GetSurfacePitch(IDirect3DSurface9 pSrcSurface,UINT* pSurfacePitch); 493 HRESULT StartSessionKeyRefresh(VOID* pRandomNumber,UINT RandomNumberSize); 494 HRESULT FinishSessionKeyRefresh(); 495 HRESULT GetEncryptionBltKey(VOID* pReadbackKey,UINT KeySize); 496 } 497 498 struct D3DOVERLAYCAPS { 499 UINT Caps; 500 UINT MaxOverlayDisplayWidth; 501 UINT MaxOverlayDisplayHeight; 502 } 503 504 struct D3DCONTENTPROTECTIONCAPS { 505 DWORD Caps; 506 GUID KeyExchangeType; 507 UINT BufferAlignmentStart; 508 UINT BlockAlignmentSize; 509 ULONGLONG ProtectedMemorySize; 510 } 511 512 enum D3D_OMAC_SIZE = 16; 513 514 struct D3D_OMAC { 515 BYTE[D3D_OMAC_SIZE] Omac; 516 } 517 518 alias D3DAUTHENTICATEDCHANNELTYPE = DWORD; 519 enum : D3DAUTHENTICATEDCHANNELTYPE { 520 D3DAUTHENTICATEDCHANNEL_D3D9 = 1, 521 D3DAUTHENTICATEDCHANNEL_DRIVER_SOFTWARE = 2, 522 D3DAUTHENTICATEDCHANNEL_DRIVER_HARDWARE = 3, 523 } 524 525 struct D3DAUTHENTICATEDCHANNEL_CONFIGURE_OUTPUT { 526 D3D_OMAC omac; 527 GUID ConfigureType; 528 HANDLE hChannel; 529 UINT SequenceNumber; 530 HRESULT ReturnCode; 531 } 532 533 struct D3DENCRYPTED_BLOCK_INFO { 534 UINT NumEncryptedBytesAtBeginning; 535 UINT NumBytesInSkipPattern; 536 UINT NumBytesInEncryptPattern; 537 } 538 539 __gshared LPDIRECT3DCREATE9 Direct3DCreate9; 540 __gshared LPDIRECT3DCREATE9EX Direct3DCreate9Ex; 541 542 extern (Windows) { 543 alias LPDIRECT3DCREATE9 = IDirect3D9 function(UINT SDKVersion); 544 545 alias LPDIRECT3DCREATE9EX = HRESULT function(UINT SDKVersion, 546 IDirect3D9Ex* ppD3D); 547 } 548 549 enum D3D_SDK_VERSION = 32;